package container

import (
	"errors"
	"gitee.com/huanminabc/go-utils/common"
	"strings"
)

// TextCol 列
type TextCol[V comparable] struct {
	Text V
}

// TextRow 行
type TextRow[V comparable] struct {
	Col []TextCol[V]
}

// TextTable 表
type TextTable[V comparable] struct {
	Row []TextRow[V]
}

// 获取行
func (t *TextTable[V]) GetRow(row int) (TextRow[V], error) {
	index, err := common.GetSliceIndex[TextRow[V]](&t.Row, row)
	if err != nil {
		return TextRow[V]{}, errors.New("行不存在")
	}
	return index, nil
}

// 获取列
func (t *TextTable[V]) GetCol(row, col int) (TextCol[V], error) {
	//判断行是否存在
	if len(t.Row) <= row {
		return TextCol[V]{}, errors.New("行不存在")
	}
	index, err := common.GetSliceIndex[TextCol[V]](&t.Row[row].Col, col)
	if err != nil {
		return TextCol[V]{}, errors.New("列不存在")
	}
	return index, nil
}

// 获取行数
func (t *TextTable[V]) GetRowNum() int {
	return len(t.Row)
}

// 获取列数
func (t *TextTable[V]) GetColNum(row int) int {
	//判断行是否存在
	if len(t.Row) <= row {
		return 0
	}
	return len(t.Row[row].Col)
}

// 获取全部元素的个数
func (t *TextTable[V]) GetNum() int {
	num := 0
	for _, v := range t.Row {
		num += len(v.Col)
	}
	return num

}

// 迭代行
func (t *TextTable[V]) RangeRow(f func(row int, textRow TextRow[V]) bool) {
	for i, v := range t.Row {
		if !f(i, v) {
			break
		}
	}
}

// 迭代指定行的列
func (t *TextTable[V]) RangeCol(row int, f func(col int, textCol TextCol[V]) bool) {
	//判断行是否存在
	if len(t.Row) <= row {
		return
	}
	for i, v := range t.Row[row].Col {
		if !f(i, v) {
			break
		}
	}
}

// 迭代全部
func (t *TextTable[V]) RangeAll(f func(row, col int, textCol TextCol[V]) bool) {
	for i, v := range t.Row {
		for j, c := range v.Col {
			if !f(i, j, c) {
				return
			}
		}
	}
}

// 添加行
func (t *TextTable[V]) AddRow(textRow TextRow[V]) {
	t.Row = append(t.Row, textRow)
}

// 添加列
func (t *TextTable[V]) AddCol(row int, textCol TextCol[V]) bool {
	//判断行是否存在
	if len(t.Row) <= row {
		return false
	}
	t.Row[row].Col = append(t.Row[row].Col, textCol)
	return true
}

// 插入行
func (t *TextTable[V]) InsertRow(row int, textRow TextRow[V]) bool {
	return common.InsertSlice(&t.Row, row, textRow)
}

// 插入列
func (t *TextTable[V]) InsertCol(row, col int, textCol TextCol[V]) bool {
	return common.InsertSlice(&t.Row[row].Col, col, textCol)
}

// 删除行
func (t *TextTable[V]) DelRow(row int) bool {
	return common.DelSlice(&t.Row, row)
}

// 删除列
func (t *TextTable[V]) DelCol(row, col int) bool {
	//判断行是否存在
	if len(t.Row) <= row {
		return false
	}
	common.DelSlice(&t.Row[row].Col, col)
	return true
}

// 覆盖行
func (t *TextTable[V]) CoverRow(row int, textRow TextRow[V]) bool {
	//判断行是否存在
	if len(t.Row) <= row {
		return false
	}
	t.Row[row] = textRow
	return true
}

// 覆盖列
func (t *TextTable[V]) CoverCol(row, col int, textCol TextCol[V]) bool {
	//判断行是否存在
	if len(t.Row) <= row {
		return false
	}
	//判断列是否存在
	if len(t.Row[row].Col) <= col {
		return false
	}
	t.Row[row].Col[col] = textCol
	return true
}

// 创建表格
func NewTextTable[V comparable]() TextTable[V] {
	return TextTable[V]{}
}

// 创建行
func NewTextRow[V comparable](v ...TextCol[V]) TextRow[V] {
	return TextRow[V]{Col: v}
}

// 创建列
func NewTextCol[V comparable](text V) TextCol[V] {
	return TextCol[V]{Text: text}
}

// 创建行列
func NewTextRowCol[V comparable](v ...V) TextRow[V] {
	textRow := TextRow[V]{}
	for _, c := range v {
		textCol := TextCol[V]{Text: c}
		textRow.Col = append(textRow.Col, textCol)
	}
	return textRow
}

// 将字符串转换成表格
func TextToTable(text string, row string, col string) TextTable[string] {
	var textTableVar = TextTable[string]{}
	textTableVar.Row = []TextRow[string]{}
	//分割行
	rows := strings.Split(text, row)
	for _, v := range rows {
		cols := strings.Split(v, col)
		//创建行
		textRow := TextRow[string]{}
		//插入到表格中
		textTableVar.Row = append(textTableVar.Row, textRow)
		//按单个字符分割
		for _, c := range cols {
			//创建列
			textCol := TextCol[string]{Text: string(c)}
			//插入到行中
			textTableVar.Row[len(textTableVar.Row)-1].Col = append(textTableVar.Row[len(textTableVar.Row)-1].Col, textCol)
		}
	}
	return textTableVar
}
